package com.stylefeng.guns.rest.modular.film;

import com.alibaba.dubbo.config.annotation.Reference;
import com.alibaba.dubbo.rpc.RpcContext;
import com.stylefeng.guns.api.film.FilmAsyncServiceAPI;
import com.stylefeng.guns.api.film.FilmServiceAPI;
import com.stylefeng.guns.api.film.vo.*;
import com.stylefeng.guns.rest.modular.film.vo.FilmConditionVO;
import com.stylefeng.guns.rest.modular.film.vo.FilmIndexVO;
import com.stylefeng.guns.rest.modular.film.vo.FilmRequestVO;
import com.stylefeng.guns.rest.modular.vo.ResponseVO;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

/**
 * @ClassName FilmController
 * Created by zghgchao 2019/8/6 9:36
 **/
@RestController
@RequestMapping("/film")
public class FilmController {

    private static final String IMG_PRE = "http://img.meetingshop.cn";

    @Reference(interfaceClass = FilmServiceAPI.class)
    private FilmServiceAPI filmServiceAPI;

    @Reference(interfaceClass = FilmAsyncServiceAPI.class,async = true)
    private FilmAsyncServiceAPI filmAsyncServiceAPI;

    /**
     * 获取首页信息：
     *      1.获取banner信息
     *      2.获取正在热映的电影
     *      3.获取即将上映的电影
     *      4.获取票房排行榜
     *      5.获取受欢迎的榜单
     *      6.获取前一百
     * API网关：
     *      1.功能聚合【API聚合】
     *      好处：
     *          1.六个接口，一次请求，同一时刻节省了五次HTTP请求
     *          2.同一个接口对外暴露，降低了前后端分离开发的难度和复杂度
     *      坏处：
     *          1.一次获取数据过多，容易出现问题
     * @return
     */
    @GetMapping("/getIndex")
    public ResponseVO getIndex(){

        FilmIndexVO filmIndexVO = new FilmIndexVO();

        // 1.获取banner信息
        filmIndexVO.setBanners(filmServiceAPI.getBanners());

        // 2.获取正在热映的电影
        filmIndexVO.setHotFilms(filmServiceAPI.getHotFilms(true,8,1,1,99,99,99));

        // 3.获取即将上映的电影
        filmIndexVO.setSoonFilms(filmServiceAPI.getSoonFilms(true,8,1,1,99,99,99));

        // 4.获取票房排行榜
        filmIndexVO.setBoxRanking(filmServiceAPI.getBoxRanking());

        // 5.获取受欢迎的榜单
        filmIndexVO.setExpectrRanking(filmServiceAPI.getExpectRanking());

        // 6.获取前一百
        filmIndexVO.setTop100(filmServiceAPI.getTop());

        return ResponseVO.success(IMG_PRE,filmIndexVO);
    }

    /**
     *
     * @param catId         类型编号
     * @param sourceId      片源编号
     * @param yearId        年代编号
     * @return
     */
    @GetMapping("/getConditionList")
    public ResponseVO getConditionList(@RequestParam(name = "catId",required = false,defaultValue = "99") String catId,
                                       @RequestParam(name = "sourceId",required = false,defaultValue = "99")String sourceId,
                                       @RequestParam(name = "yearId",required = false,defaultValue = "99")String yearId){

        FilmConditionVO filmConditionVO = new FilmConditionVO();

        // 类型集合
        boolean flag = false; // 标志位
        List<CatVO> cats = filmServiceAPI.getCats();
        List<CatVO> catResult = new ArrayList<>();
        CatVO cat = null;
        for (CatVO catVO : cats) {
            // 判断集合是否存在catId,如果存在，则将对应的实体变成active状态
            // 1，2，3，99，4，5   // 传参：6
            // 优化【1.数据层查询按id进行排序，2.通过2分法查找】
            if (catVO.getCatId().equals("99")){
                cat = catVO;
                continue;
            }
            if (catVO.getCatId().equals(catId)){
                flag = true;
                catVO.setActive(true);
            }
            catResult.add(catVO);
        }
        // 如果不存在，则默认将全部变为Active状态
        if (!flag){
            // 将id为99的全部置为true
            cat.setActive(true);
        }
        catResult.add(cat);

        // 片源集合
        flag = false; // 标志位
        List<SourceVO> sources = filmServiceAPI.getSources();
        List<SourceVO> sourceResult = new ArrayList<>();
        SourceVO source = null;
        for (SourceVO sourceVO : sources) {
            // 判断集合是否存在catId,如果存在，则将对应的实体变成active状态
            // 1，2，3，99，4，5   // 传参：6
            // 优化【1.数据层查询按id进行排序，2.通过2分法查找】
            if (sourceVO.getSourceId().equals("99")){
                source = sourceVO;
                continue;
            }
            if (sourceVO.getSourceId().equals(catId)){
                flag = true;
                sourceVO.setActive(true);
            }
            sourceResult.add(sourceVO);
        }
        // 如果不存在，则默认将全部变为Active状态
        if (!flag){
            // 将id为99的全部置为true
            source.setActive(true);
        }
        sourceResult.add(source);

        // 年代集合
        flag = false; // 标志位
        List<YearVO> years = filmServiceAPI.getYears();
        List<YearVO> yearResult = new ArrayList<>();
        YearVO year = null;
        for (YearVO yearVO : years) {
            // 判断集合是否存在catId,如果存在，则将对应的实体变成active状态
            // 1，2，3，99，4，5   // 传参：6
            // 优化【1.数据层查询按id进行排序，2.通过2分法查找】
            if (yearVO.getYearId().equals("99")){
                year = yearVO;
                continue;
            }
            if (yearVO.getYearId().equals(catId)){
                flag = true;
                yearVO.setActive(true);
            }
            yearResult.add(yearVO);
        }
        // 如果不存在，则默认将全部变为Active状态
        if (!flag){
            // 将id为99的全部置为true
            year.setActive(true);
        }
        yearResult.add(year);

        filmConditionVO.setCatInfo(catResult);
        filmConditionVO.setSourceInfo(sourceResult);
        filmConditionVO.setYearInfo(yearResult);

        return ResponseVO.success(filmConditionVO);
    }

    @GetMapping(value = "/getFilms")
    public ResponseVO getFilms(FilmRequestVO filmRequestVO){

        FilmVO filmVO = null;

        // 根据showType判断影片查询类型 查询类型：1-正在热映，2-即将上映，3-经典影片 默认为1
        switch (filmRequestVO.getShowType()){
            case 1:
                filmVO = filmServiceAPI.getHotFilms(false,filmRequestVO.getPageSize(),filmRequestVO.getNowPage(),
                        filmRequestVO.getSortId(),filmRequestVO.getSourceId(),filmRequestVO.getYearId(),filmRequestVO.getCatId());
                break;
            case 2:
                filmVO = filmServiceAPI.getSoonFilms(false,filmRequestVO.getPageSize(),filmRequestVO.getNowPage(),
                        filmRequestVO.getSortId(),filmRequestVO.getSourceId(),filmRequestVO.getYearId(),filmRequestVO.getCatId());
                break;
            case 3:
                filmVO = filmServiceAPI.getClassicFilms(filmRequestVO.getPageSize(),filmRequestVO.getNowPage(),
                        filmRequestVO.getSortId(),filmRequestVO.getSourceId(),filmRequestVO.getYearId(),filmRequestVO.getCatId());
                break;
            default:
                filmVO = filmServiceAPI.getHotFilms(false,filmRequestVO.getPageSize(),filmRequestVO.getNowPage(),
                        filmRequestVO.getSortId(),filmRequestVO.getSourceId(),filmRequestVO.getYearId(),filmRequestVO.getCatId());
                break;
        }
        // 根据sortId排序
        // 添加各种条件查询
        // 判断当前是第几页

        return ResponseVO.success(filmVO.getNowPage(),filmVO.getTotalPage(),IMG_PRE,filmVO.getFilmInfo()  );
    }

    @GetMapping(value = "/films/{searchParam}")
    public ResponseVO films(@PathVariable("searchParam") String searchParam,@RequestParam("searchType") int searchType) throws ExecutionException, InterruptedException {
        // 根据searchType，判断查询类型
        FilmDetailVO filmDetail = filmServiceAPI.getFilmDetail(searchType, searchParam);
        String filmId = filmDetail.getFilmId();

        if (filmDetail == null){
            return ResponseVO.serviceFail("没有可查询的影片！");
        }else if (filmDetail.getFilmId() == null || filmDetail.getFilmId().trim().length() == 0){
            return ResponseVO.serviceFail("没有可查询的影片！");

        }

        // 查询影片的详细信息 -> Dubbo的异步获取
        // 获取影片描述信息
        filmAsyncServiceAPI.getFilmDesc(filmId);
        Future<FilmDescVO> filmDescVOFuture = RpcContext.getContext().getFuture();
        // 获取图片信息
        filmAsyncServiceAPI.getImgs(filmId);
        Future<ImgVO> imgVOFuture = RpcContext.getContext().getFuture();

        filmAsyncServiceAPI.getDectInfo(filmId);
        Future<ActorVO> actorVOFuture = RpcContext.getContext().getFuture();

        // 获取演员信息
        filmAsyncServiceAPI.getActors(filmId);
        Future<List<ActorVO>> actorsFuture = RpcContext.getContext().getFuture();

        // 组织info对象
        InfoRequestVO infoRequestVO = new InfoRequestVO();

        // 组织Actor对象
        ActorRequestVO actorRequestVO = new ActorRequestVO();
        actorRequestVO.setActors(actorsFuture.get());
        actorRequestVO.setDirector(actorVOFuture.get());

        // 组织info对象
        infoRequestVO.setActors(actorRequestVO);
        infoRequestVO.setBiography(filmDescVOFuture.get().getBiography());
        infoRequestVO.setFilmId(filmId);
        infoRequestVO.setImgs(imgVOFuture.get());

        // 组织成返回值
        filmDetail.setInfo04(infoRequestVO);

        return ResponseVO.success(IMG_PRE,filmDetail);
    }
}
